package main

import (
	"fmt"
	"os"
)

//处理opton.json文件中的数据信息，通过simplejson解析json的元素
func HandleJson(filename string, chanX <-chan interface{}, chanY <-chan interface{}) error {

	//获取文件的字节序列
	fileBytes, err := getFileBytes(filename)
	if err != nil {
		fmt.Printf("getBytes error :%s\n", err)
		return err
	}
	//去掉最后的“;”，否则无法正确解析json
	fileBytes = fileBytes[:len(fileBytes)-1]
	//处理字节序
	res, err := handleBytes(fileBytes, chanX, chanY)
	if err != nil {
		fmt.Printf("handleBytes  error :%s\n", err)
		return err
	}
	//最后加入那个";"
	res = append(res, ';')
	//存入文件
	err = setBytesToFile(filename, res)
	if err != nil {
		fmt.Printf("setBytesToFile err :%s\n", err)
		return err
	}

	return nil
}

func getFileBytes(filename string) ([]byte, error) {
	file, err := os.OpenFile(filename, os.O_RDWR, 0666)
	if err != nil {
		return nil, err
	}
	fileinfo, _ := os.Stat(filename)
	size := fileinfo.Size()
	fileBytes := make([]byte, size)

	if n, err := file.Read(fileBytes); n == 0 || err != nil{
		fmt.Printf("file read err :%v\n", err)
	}

	file.Close()
	return fileBytes, nil
}

func setBytesToFile(filename string, data []byte) error {
	file, err := os.OpenFile(filename, os.O_WRONLY|os.O_TRUNC, 0666)
	if err != nil {
		return err
	}
	_, err = file.WriteAt(data, 0)
	if err != nil {
		return err
	}

	file.Close()
	return nil
}

func handleBytes(fileBytes []byte, chanX <-chan interface{}, chanY <-chan interface{}) ([]byte, error) {
	var i int
	var b byte
	flagA := make(chan bool, 1)
	flagB := make(chan bool, 1)
	for i, b = range fileBytes {
		if b == '\n' {
			break
		}
	}
	//去掉开头一行
	fileBytesHead := fileBytes[:i+1]

	//	获取json对象
	g, err := NewJson(fileBytes[i:])
	if err != nil {
		fmt.Println("NewJson: ", err.Error())
		return nil, err
	}

	go func() {
		//获取xAxis中的data，处理data的值
		if err := handleValue(g, "xAxis", chanX); err != nil {
			fmt.Printf("HandlexAxis error :%s\n", err)
			return
		}
		flagA <- true
	}()

	go func() {
		//获取series中的data，处理data的值
		if err := handleValue(g, "series", chanY); err != nil {
			fmt.Printf("HandleSeries error :%s\n", err)
			return
		}
		flagB <- true
	}()

	//	等待两个goroutine完成
	<-flagA
	<-flagB
	//将json对象序列化，获得字节序列
	res, err := g.MarshalJSON()
	if err != nil {
		fmt.Printf("%v\n", err)
		return nil, err
	}
	res = append(fileBytesHead, res...)
	return res, nil
}

func handleValue(g *Json, item string, c <-chan interface{}) error {
	s := g.Get(item)
	//得到series对象
	s_a, err := s.Array()
	if err != nil {
		fmt.Printf("%v\n", err)
		return err
	}
	dataMap := (s_a[0]).(map[string]interface{})
	dataMap["data"] = getData(c)
	return nil
}

func getData(c <-chan interface{}) []interface{} {
	var data []interface{}

	for {
		t, ok := <-c
		if !ok {
			fmt.Printf("data has recevied!\n")
			break
		}
		data = append(data, t)
	}
	return data
}
